Run time compiling generally involves the use of a dynamic compiler. Run time compiling with dynamic compilers is commonly used in execution of JAVA code. A variety of dynamic compilers with varying attributes such as Just In Time (JIT) compilers have been employed for this purpose, some being optimizing compilers and some not.
These prior art dynamic compilers generally translate or compile entire methods or subroutines at a time. Therefore, even if only part of the method will actually be executed with substantial frequency, the entire method will still generally be compiled. The compilation of portions of a method or subroutine which will not be frequently executed represents an inefficient commitment of computational effort to the compiling process. This inefficiency remains even if the compiled method is frequently called by the calling routine, and if portions of the method are frequently executed.
Run time compiling may generally be improved through the use of various optimizing techniques. These techniques typically require that the compiler have substantial knowledge of the execution path which will be realized at run time. Prior art dynamic compilers typically do not have complete information on the execution paths likely to occur at run time, and therefore are not able to effectively optimize execution of the source code.
When using JAVA, “type” information describing what type of objects exist within the source code is embedded therein. The availability of this “type” information at run time permits still further optimization of execution at run time.
Therefore, it is a problem in the art that dynamic compilers must translate entire methods at a time even though only certain portions of the method will be frequently executed.
It is a further problem in the art that prior art dynamic compilers do not have complete execution path information, thereby preventing optimization of compilation and execution at run time.